/*
 * Rust 无符号整数类型详解 - u8, u16, u32, u64
 * 
 * 本程序详细介绍了Rust中的无符号整数类型，包括：
 * - u8:  8位无符号整数  （0 到 255）
 * - u16: 16位无符号整数 （0 到 65,535）  
 * - u32: 32位无符号整数 （0 到 4,294,967,295）
 * - u64: 64位无符号整数 （0 到 18,446,744,073,709,551,615）
 * 
 * 学习目标：
 * 1. 理解无符号整数与有符号整数的区别
 * 2. 掌握无符号整数类型的存储范围和特点
 * 3. 学习无符号整数的典型应用场景
 * 4. 了解无符号整数的安全使用方法
 * 5. 掌握类型转换和边界处理
 */

fn main() {
    println!("🦀 欢迎学习 Rust 无符号整数类型！");
    println!("{}", "=".repeat(55));
    
    // ===== 第一部分：无符号整数基础概念 =====
    println!("\n📌 第一部分：无符号整数基础概念");
    
    println!("无符号整数的特点：");
    println!("✅ 只能存储非负数（0和正数）");
    println!("✅ 没有符号位，所有位都用于存储数值");
    println!("✅ 相同位数下能表示更大的正数");
    println!("✅ 不会有负数溢出问题");
    
    // ===== 第二部分：基本无符号整数类型声明 =====
    println!("\n📌 第二部分：基本无符号整数类型声明");
    
    // u8: 8位无符号整数，占用1个字节
    // 范围：0 到 255
    let byte_value: u8 = 200;
    let max_u8: u8 = 255;
    
    println!("u8 类型示例：");
    println!("  数值: {} (占用 {} 字节)", byte_value, std::mem::size_of::<u8>());
    println!("  最大值: {} (占用 {} 字节)", max_u8, std::mem::size_of::<u8>());
    
    // u16: 16位无符号整数，占用2个字节  
    // 范围：0 到 65,535
    let port_number: u16 = 8080;
    let max_u16: u16 = 65535;
    
    println!("\nu16 类型示例：");
    println!("  端口号: {} (占用 {} 字节)", port_number, std::mem::size_of::<u16>());
    println!("  最大值: {} (占用 {} 字节)", max_u16, std::mem::size_of::<u16>());
    
    // u32: 32位无符号整数，占用4个字节
    // 范围：0 到 4,294,967,295
    let large_count: u32 = 3_000_000_000;
    let max_u32: u32 = 4_294_967_295;
    
    println!("\nu32 类型示例：");
    println!("  大数计数: {} (占用 {} 字节)", large_count, std::mem::size_of::<u32>());
    println!("  最大值: {} (占用 {} 字节)", max_u32, std::mem::size_of::<u32>());
    
    // u64: 64位无符号整数，占用8个字节
    // 范围：0 到 18,446,744,073,709,551,615
    let huge_number: u64 = 15_000_000_000_000_000_000;
    let max_u64: u64 = 18_446_744_073_709_551_615;
    
    println!("\nu64 类型示例：");
    println!("  超大数值: {} (占用 {} 字节)", huge_number, std::mem::size_of::<u64>());
    println!("  最大值: {} (占用 {} 字节)", max_u64, std::mem::size_of::<u64>());
    
    // ===== 第三部分：无符号与有符号整数对比 =====
    println!("\n📌 第三部分：无符号与有符号整数对比");
    
    println!("类型对比（相同位数）：");
    println!("| 类型 | 最小值 | 最大值 |");
    println!("| i8   | {}   | {} |", i8::MIN, i8::MAX);
    println!("| u8   | {}     | {} |", u8::MIN, u8::MAX);
    println!("| i16  | {}  | {} |", i16::MIN, i16::MAX);
    println!("| u16  | {}     | {} |", u16::MIN, u16::MAX);
    
    // 展示范围优势
    let signed_max: i32 = i32::MAX;
    let unsigned_max: u32 = u32::MAX;
    println!("\n范围对比示例：");
    println!("i32 最大值: {} ({:.2}万)", signed_max, signed_max as f64 / 10000.0);
    println!("u32 最大值: {} ({:.2}万)", unsigned_max, unsigned_max as f64 / 10000.0);
    println!("u32 比 i32 能表示多 {:.2} 倍的数值！", unsigned_max as f64 / signed_max as f64);
    
    // ===== 第四部分：各无符号类型的数值范围 =====
    println!("\n📌 第四部分：各无符号类型的数值范围");
    
    println!("u8  范围: {} 到 {}", u8::MIN, u8::MAX);
    println!("u16 范围: {} 到 {}", u16::MIN, u16::MAX);
    println!("u32 范围: {} 到 {}", u32::MIN, u32::MAX);
    println!("u64 范围: {} 到 {}", u64::MIN, u64::MAX);
    
    // ===== 第五部分：实际应用场景 =====
    println!("\n📌 第五部分：实际应用场景");
    
    // u8: 字节数据、颜色值、百分比等
    let red_component: u8 = 255;    // RGB 红色分量
    let progress: u8 = 85;          // 85% 进度
    let ascii_code: u8 = 65;        // 字符 'A' 的ASCII码
    println!("u8 应用场景：");
    println!("  RGB红色分量: {}", red_component);
    println!("  进度百分比: {}%", progress);
    println!("  ASCII码: {} (字符 '{}')", ascii_code, ascii_code as char);
    
    // u16: 端口号、像素坐标、小型ID等
    let http_port: u16 = 80;
    let https_port: u16 = 443;
    let screen_width: u16 = 1920;
    println!("\nu16 应用场景：");
    println!("  HTTP端口: {}", http_port);
    println!("  HTTPS端口: {}", https_port);
    println!("  屏幕宽度: {}像素", screen_width);
    
    // u32: 用户ID、文件大小、IP地址等
    let user_id: u32 = 1234567890;
    let file_size: u32 = 52_428_800; // 50MB
    let ipv4_address: u32 = 0xC0A80001; // 192.168.0.1
    println!("\nu32 应用场景：");
    println!("  用户ID: {}", user_id);
    println!("  文件大小: {} 字节 ({:.1} MB)", file_size, file_size as f64 / 1_048_576.0);
    println!("  IPv4地址(数值): 0x{:08X}", ipv4_address);
    
    // u64: 大文件大小、高精度时间戳、大数据计数
    let large_file_size: u64 = 17_179_869_184; // 16GB
    let nanosecond_timestamp: u64 = 1694000000123456789;
    let webpage_views: u64 = 5_000_000_000_000;
    println!("\nu64 应用场景：");
    println!("  大文件大小: {} 字节 ({:.1} GB)", large_file_size, large_file_size as f64 / 1_073_741_824.0);
    println!("  纳秒时间戳: {}", nanosecond_timestamp);
    println!("  网页访问量: {}", webpage_views);
    
    // ===== 第六部分：类型指定和字面量 =====
    println!("\n📌 第六部分：类型指定和字面量");
    
    // 后缀指定类型
    let explicit_u8 = 100u8;
    let explicit_u16 = 5000u16;
    let explicit_u32 = 1000000u32;
    let explicit_u64 = 10000000000u64;
    
    println!("使用后缀明确指定类型：");
    println!("  100u8 = {}", explicit_u8);
    println!("  5000u16 = {}", explicit_u16);
    println!("  1000000u32 = {}", explicit_u32);
    println!("  10000000000u64 = {}", explicit_u64);
    
    // 不同进制表示
    let hex_color: u32 = 0xFF6B35;     // 十六进制颜色
    let binary_mask: u8 = 0b1111_0000; // 二进制掩码
    let octal_permission: u16 = 0o755; // 八进制权限
    
    println!("\n不同进制的无符号整数：");
    println!("  十六进制颜色: 0x{:06X} ({})", hex_color, hex_color);
    println!("  二进制掩码: 0b{:08b} ({})", binary_mask, binary_mask);
    println!("  八进制权限: 0o{:o} ({})", octal_permission, octal_permission);
    
    // ===== 第七部分：数学运算 =====
    println!("\n📌 第七部分：基本数学运算");
    
    let a: u32 = 100;
    let b: u32 = 30;
    
    println!("无符号整数运算示例 (a = {}, b = {})：", a, b);
    println!("  加法: {} + {} = {}", a, b, a + b);
    println!("  减法: {} - {} = {}", a, b, a - b);  // 注意：无符号数不能小于0
    println!("  乘法: {} * {} = {}", a, b, a * b);
    println!("  除法: {} / {} = {}", a, b, a / b);
    println!("  取余: {} % {} = {}", a, b, a % b);
    
    // ===== 第八部分：边界和安全性 =====
    println!("\n📌 第八部分：边界和安全性注意事项");
    
    println!("无符号整数安全使用要点：");
    println!("⚠️  减法运算：确保被减数不小于减数");
    println!("⚠️  类型转换：注意范围溢出问题");
    println!("⚠️  与有符号数混用：可能导致意外结果");
    
    // 安全的边界检查示例
    let big_num: u8 = 200;
    let small_num: u8 = 50;
    
    if big_num >= small_num {
        println!("✅ 安全减法: {} - {} = {}", big_num, small_num, big_num - small_num);
    } else {
        println!("❌ 危险操作：{} 小于 {}，不能相减", big_num, small_num);
    }
    
    // 展示最大值
    println!("\n各类型的最大值展示：");
    println!("u8::MAX  = {} (可存储 {} 个不同值)", u8::MAX, u8::MAX as u32 + 1);
    println!("u16::MAX = {} (可存储 {} 个不同值)", u16::MAX, u16::MAX as u32 + 1);
    println!("u32::MAX = {} (可存储 {} 个不同值)", u32::MAX, u32::MAX as u64 + 1);
    println!("u64::MAX = {} (天文数字！)", u64::MAX);
    
    // ===== 总结 =====
    println!("\n🎯 学习总结：");
    println!("1. 无符号整数只能存储非负数，但范围更大");
    println!("2. u8 适合字节数据，u16 适合端口/坐标，u32 适合ID/计数，u64 适合大数据");
    println!("3. 使用无符号数时要特别注意减法和边界问题");
    println!("4. 根据数据特性选择合适的无符号类型可以优化内存使用");
    println!("5. 无符号整数在系统编程、图形处理、网络编程中应用广泛");
    
    println!("\n🚀 恭喜！你已经掌握了 Rust 无符号整数类型的核心知识！");
}
